home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / utils / ObjectUtil.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  25.7 KB  |  833 lines
  1. package mx.utils
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import flash.utils.getQualifiedClassName;
  6.    import flash.xml.XMLNode;
  7.    import mx.collections.IList;
  8.    import mx.core.mx_internal;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class ObjectUtil
  13.    {
  14.       mx_internal static const VERSION:String = "2.0.1.0";
  15.       
  16.       private static var refCount:int = 0;
  17.       
  18.       private static var CLASS_INFO_CACHE:Object = {};
  19.       
  20.       public function ObjectUtil()
  21.       {
  22.          super();
  23.       }
  24.       
  25.       private static function recordMetadata(param1:XMLList) : Object
  26.       {
  27.          var result:Object = null;
  28.          var prop:XML = null;
  29.          var propName:String = null;
  30.          var metadataList:XMLList = null;
  31.          var metadata:Object = null;
  32.          var md:XML = null;
  33.          var mdName:String = null;
  34.          var argsList:XMLList = null;
  35.          var value:Object = null;
  36.          var arg:XML = null;
  37.          var existing:Object = null;
  38.          var argKey:String = null;
  39.          var argValue:String = null;
  40.          var existingArray:Array = null;
  41.          var properties:XMLList = param1;
  42.          result = null;
  43.          try
  44.          {
  45.             for each(prop in properties)
  46.             {
  47.                propName = prop.attribute("name").toString();
  48.                metadataList = prop.metadata;
  49.                if(metadataList.length() > 0)
  50.                {
  51.                   if(result == null)
  52.                   {
  53.                      result = {};
  54.                   }
  55.                   metadata = {};
  56.                   result[propName] = metadata;
  57.                   for each(md in metadataList)
  58.                   {
  59.                      mdName = md.attribute("name").toString();
  60.                      argsList = md.arg;
  61.                      value = {};
  62.                      for each(arg in argsList)
  63.                      {
  64.                         argKey = arg.attribute("key").toString();
  65.                         if(argKey != null)
  66.                         {
  67.                            argValue = arg.attribute("value").toString();
  68.                            value[argKey] = argValue;
  69.                         }
  70.                      }
  71.                      existing = metadata[mdName];
  72.                      if(existing != null)
  73.                      {
  74.                         if(existing is Array)
  75.                         {
  76.                            existingArray = existing as Array;
  77.                         }
  78.                         else
  79.                         {
  80.                            existingArray = [];
  81.                         }
  82.                         existingArray.push(value);
  83.                         existing = existingArray;
  84.                      }
  85.                      else
  86.                      {
  87.                         existing = value;
  88.                      }
  89.                      metadata[mdName] = existing;
  90.                   }
  91.                }
  92.             }
  93.          }
  94.          catch(e:Error)
  95.          {
  96.          }
  97.          return result;
  98.       }
  99.       
  100.       public static function hasMetadata(param1:Object, param2:String, param3:String, param4:Array = null, param5:Object = null) : Boolean
  101.       {
  102.          var _loc6_:Object = null;
  103.          var _loc7_:Object = null;
  104.          _loc6_ = getClassInfo(param1,param4,param5);
  105.          _loc7_ = _loc6_["metadata"];
  106.          return internalHasMetadata(_loc7_,param2,param3);
  107.       }
  108.       
  109.       private static function byteArrayCompare(param1:ByteArray, param2:ByteArray) : int
  110.       {
  111.          var _loc3_:int = 0;
  112.          var _loc4_:int = 0;
  113.          _loc3_ = 0;
  114.          if(param1.length != param2.length)
  115.          {
  116.             if(param1.length < param2.length)
  117.             {
  118.                _loc3_ = -1;
  119.             }
  120.             else
  121.             {
  122.                _loc3_ = 1;
  123.             }
  124.          }
  125.          else
  126.          {
  127.             param1.position = 0;
  128.             param2.position = 0;
  129.             _loc4_ = 0;
  130.             while(_loc4_ < param1.length)
  131.             {
  132.                _loc3_ = numericCompare(param1.readByte(),param2.readByte());
  133.                if(_loc3_ != 0)
  134.                {
  135.                   _loc4_ = int(param1.length);
  136.                }
  137.                _loc4_++;
  138.             }
  139.          }
  140.          return _loc3_;
  141.       }
  142.       
  143.       private static function arrayCompare(param1:Array, param2:Array, param3:int, param4:int, param5:Dictionary) : int
  144.       {
  145.          var _loc6_:int = 0;
  146.          var _loc7_:int = 0;
  147.          _loc6_ = 0;
  148.          if(param1.length != param2.length)
  149.          {
  150.             if(param1.length < param2.length)
  151.             {
  152.                _loc6_ = -1;
  153.             }
  154.             else
  155.             {
  156.                _loc6_ = 1;
  157.             }
  158.          }
  159.          else
  160.          {
  161.             _loc7_ = 0;
  162.             while(_loc7_ < param1.length)
  163.             {
  164.                _loc6_ = internalCompare(param1[_loc7_],param2[_loc7_],param3,param4,param5);
  165.                if(_loc6_ != 0)
  166.                {
  167.                   _loc7_ = int(param1.length);
  168.                }
  169.                _loc7_++;
  170.             }
  171.          }
  172.          return _loc6_;
  173.       }
  174.       
  175.       public static function compare(param1:Object, param2:Object, param3:int = -1) : int
  176.       {
  177.          return internalCompare(param1,param2,0,param3,new Dictionary(true));
  178.       }
  179.       
  180.       private static function listCompare(param1:IList, param2:IList, param3:int, param4:int, param5:Dictionary) : int
  181.       {
  182.          var _loc6_:int = 0;
  183.          var _loc7_:int = 0;
  184.          _loc6_ = 0;
  185.          if(param1.length != param2.length)
  186.          {
  187.             if(param1.length < param2.length)
  188.             {
  189.                _loc6_ = -1;
  190.             }
  191.             else
  192.             {
  193.                _loc6_ = 1;
  194.             }
  195.          }
  196.          else
  197.          {
  198.             _loc7_ = 0;
  199.             while(_loc7_ < param1.length)
  200.             {
  201.                _loc6_ = internalCompare(param1.getItemAt(_loc7_),param2.getItemAt(_loc7_),param3 + 1,param4,param5);
  202.                if(_loc6_ != 0)
  203.                {
  204.                   _loc7_ = param1.length;
  205.                }
  206.                _loc7_++;
  207.             }
  208.          }
  209.          return _loc6_;
  210.       }
  211.       
  212.       private static function internalCompare(param1:Object, param2:Object, param3:int, param4:int, param5:Dictionary) : int
  213.       {
  214.          var _loc6_:* = null;
  215.          var _loc7_:* = null;
  216.          var _loc8_:int = 0;
  217.          var _loc9_:int = 0;
  218.          var _loc10_:Boolean = false;
  219.          var _loc11_:Boolean = false;
  220.          var _loc12_:Array = null;
  221.          var _loc13_:Array = null;
  222.          var _loc14_:QName = null;
  223.          var _loc15_:Object = null;
  224.          var _loc16_:Object = null;
  225.          var _loc17_:int = 0;
  226.          if(param1 == null && param2 == null)
  227.          {
  228.             return 0;
  229.          }
  230.          if(param1 == null)
  231.          {
  232.             return 1;
  233.          }
  234.          if(param2 == null)
  235.          {
  236.             return -1;
  237.          }
  238.          if(param1 is ObjectProxy)
  239.          {
  240.             param1 = ObjectProxy(param1).object_proxy::object;
  241.          }
  242.          if(param2 is ObjectProxy)
  243.          {
  244.             param2 = ObjectProxy(param2).object_proxy::object;
  245.          }
  246.          _loc6_ = typeof param1;
  247.          _loc7_ = typeof param2;
  248.          _loc8_ = 0;
  249.          if(_loc6_ == _loc7_)
  250.          {
  251.             switch(_loc6_)
  252.             {
  253.                case "boolean":
  254.                   _loc8_ = numericCompare(Number(param1),Number(param2));
  255.                   break;
  256.                case "number":
  257.                   _loc8_ = numericCompare(param1 as Number,param2 as Number);
  258.                   break;
  259.                case "string":
  260.                   _loc8_ = stringCompare(param1 as String,param2 as String);
  261.                   break;
  262.                case "object":
  263.                   _loc9_ = param4 > 0 ? param4 - 1 : param4;
  264.                   _loc10_ = Boolean(param5[param1]);
  265.                   _loc11_ = Boolean(param5[param2]);
  266.                   if(_loc10_ && !_loc11_)
  267.                   {
  268.                      return 1;
  269.                   }
  270.                   if(_loc11_ && !_loc10_)
  271.                   {
  272.                      return -1;
  273.                   }
  274.                   if(_loc11_ && _loc10_)
  275.                   {
  276.                      return 0;
  277.                   }
  278.                   param5[param1] = true;
  279.                   param5[param2] = true;
  280.                   if(param4 != -1 && param3 > param4)
  281.                   {
  282.                      _loc8_ = stringCompare(param1.toString(),param2.toString());
  283.                   }
  284.                   else if(param1 is Array && param2 is Array)
  285.                   {
  286.                      _loc8_ = arrayCompare(param1 as Array,param2 as Array,param3,param4,param5);
  287.                   }
  288.                   else if(param1 is Date && param2 is Date)
  289.                   {
  290.                      _loc8_ = dateCompare(param1 as Date,param2 as Date);
  291.                   }
  292.                   else if(param1 is IList && param2 is IList)
  293.                   {
  294.                      _loc8_ = listCompare(param1 as IList,param2 as IList,param3,param4,param5);
  295.                   }
  296.                   else if(param1 is ByteArray && param2 is ByteArray)
  297.                   {
  298.                      _loc8_ = byteArrayCompare(param1 as ByteArray,param2 as ByteArray);
  299.                   }
  300.                   else
  301.                   {
  302.                      if(getQualifiedClassName(param1) != getQualifiedClassName(param2))
  303.                      {
  304.                         return 1;
  305.                      }
  306.                      _loc12_ = getClassInfo(param1).properties;
  307.                      if(getQualifiedClassName(param1) == "Object")
  308.                      {
  309.                         _loc13_ = getClassInfo(param2).properties;
  310.                         _loc8_ = arrayCompare(_loc12_,_loc13_,param3,_loc9_,param5);
  311.                      }
  312.                      if(_loc8_ != 0)
  313.                      {
  314.                         return _loc8_;
  315.                      }
  316.                      _loc17_ = 0;
  317.                      while(_loc17_ < _loc12_.length)
  318.                      {
  319.                         _loc14_ = _loc12_[_loc17_];
  320.                         _loc15_ = param1[_loc14_];
  321.                         _loc16_ = param2[_loc14_];
  322.                         _loc8_ = internalCompare(_loc15_,_loc16_,param3 + 1,_loc9_,param5);
  323.                         if(_loc8_ != 0)
  324.                         {
  325.                            _loc17_ = int(_loc12_.length);
  326.                         }
  327.                         _loc17_++;
  328.                      }
  329.                   }
  330.                   break;
  331.             }
  332.             return _loc8_;
  333.          }
  334.          return stringCompare(_loc6_,_loc7_);
  335.       }
  336.       
  337.       private static function internalToString(param1:Object, param2:int = 0, param3:Dictionary = null, param4:Array = null, param5:Array = null) : String
  338.       {
  339.          var _loc6_:* = null;
  340.          var _loc7_:String = null;
  341.          var _loc8_:Object = null;
  342.          var _loc9_:Array = null;
  343.          var _loc10_:Object = null;
  344.          var _loc11_:* = false;
  345.          var _loc12_:* = undefined;
  346.          var _loc13_:int = 0;
  347.          _loc7_ = param1 == null ? "null" : typeof param1;
  348.          switch(_loc7_)
  349.          {
  350.             case "boolean":
  351.             case "number":
  352.                return param1.toString();
  353.             case "string":
  354.                return "\"" + param1.toString() + "\"";
  355.             case "object":
  356.                if(param1 is Date)
  357.                {
  358.                   return param1.toString();
  359.                }
  360.                if(param1 is XMLNode)
  361.                {
  362.                   return param1.toString();
  363.                }
  364.                if(param1 is Class)
  365.                {
  366.                   return "(" + getQualifiedClassName(param1) + ")";
  367.                }
  368.                _loc8_ = getClassInfo(param1,param5,{
  369.                   "includeReadOnly":true,
  370.                   "uris":param4
  371.                });
  372.                _loc9_ = _loc8_.properties;
  373.                _loc6_ = "(" + _loc8_.name + ")";
  374.                if(param3 == null)
  375.                {
  376.                   param3 = new Dictionary(true);
  377.                }
  378.                _loc10_ = param3[param1];
  379.                if(_loc10_ != null)
  380.                {
  381.                   return _loc6_ + ("#" + int(_loc10_));
  382.                }
  383.                if(param1 != null)
  384.                {
  385.                   _loc6_ += "#" + refCount.toString();
  386.                   param3[param1] = refCount;
  387.                   ++refCount;
  388.                }
  389.                _loc11_ = param1 is Array;
  390.                param2 += 2;
  391.                _loc13_ = 0;
  392.                while(_loc13_ < _loc9_.length)
  393.                {
  394.                   _loc6_ = newline(_loc6_,param2);
  395.                   _loc12_ = _loc9_[_loc13_];
  396.                   if(_loc11_)
  397.                   {
  398.                      _loc6_ += "[";
  399.                   }
  400.                   _loc6_ += _loc12_.toString();
  401.                   if(_loc11_)
  402.                   {
  403.                      _loc6_ += "] ";
  404.                   }
  405.                   else
  406.                   {
  407.                      _loc6_ += " = ";
  408.                   }
  409.                   _loc6_ += internalToString(param1[_loc12_],param2,param3,param4,param5);
  410.                   _loc13_++;
  411.                }
  412.                param2 -= 2;
  413.                return _loc6_;
  414.                break;
  415.             case "xml":
  416.                return param1.toString();
  417.             default:
  418.                return "(" + _loc7_ + ")";
  419.          }
  420.       }
  421.       
  422.       public static function toString(param1:Object, param2:Array = null, param3:Array = null) : String
  423.       {
  424.          refCount = 0;
  425.          return internalToString(param1,0,null,param2,param3);
  426.       }
  427.       
  428.       public static function getClassInfo(param1:Object, param2:Array = null, param3:Object = null) : Object
  429.       {
  430.          var n:int = 0;
  431.          var i:int = 0;
  432.          var result:Object = null;
  433.          var propertyNames:Array = null;
  434.          var cacheKey:String = null;
  435.          var className:String = null;
  436.          var classAlias:String = null;
  437.          var properties:XMLList = null;
  438.          var prop:XML = null;
  439.          var dynamic:Boolean = false;
  440.          var metadataInfo:Object = null;
  441.          var excludeObject:Object = null;
  442.          var isArray:Boolean = false;
  443.          var classInfo:XML = null;
  444.          var numericIndex:Boolean = false;
  445.          var p:String = null;
  446.          var pi:Number = NaN;
  447.          var uris:Array = null;
  448.          var uri:String = null;
  449.          var qName:QName = null;
  450.          var j:int = 0;
  451.          var obj:Object = param1;
  452.          var excludes:Array = param2;
  453.          var options:Object = param3;
  454.          if(obj is ObjectProxy)
  455.          {
  456.             obj = ObjectProxy(obj).object_proxy::object;
  457.          }
  458.          if(options == null)
  459.          {
  460.             options = {
  461.                "includeReadOnly":true,
  462.                "uris":null,
  463.                "includeTransient":true
  464.             };
  465.          }
  466.          propertyNames = [];
  467.          dynamic = false;
  468.          if(typeof obj == "xml")
  469.          {
  470.             className = "XML";
  471.             properties = obj.text();
  472.             if(properties.length())
  473.             {
  474.                propertyNames.push("*");
  475.             }
  476.             properties = obj.attributes();
  477.          }
  478.          else
  479.          {
  480.             classInfo = DescribeTypeCache.describeType(obj).typeDescription;
  481.             className = classInfo.@name.toString();
  482.             classAlias = classInfo.@alias.toString();
  483.             dynamic = classInfo.@isDynamic.toString() == "true";
  484.             if(options.includeReadOnly)
  485.             {
  486.                properties = classInfo..accessor.(@access != "writeonly") + classInfo..variable;
  487.             }
  488.             else
  489.             {
  490.                properties = classInfo..accessor.(@access == "readwrite") + classInfo..variable;
  491.             }
  492.             numericIndex = false;
  493.          }
  494.          if(!dynamic)
  495.          {
  496.             cacheKey = getCacheKey(obj,excludes,options);
  497.             result = CLASS_INFO_CACHE[cacheKey];
  498.             if(result != null)
  499.             {
  500.                return result;
  501.             }
  502.          }
  503.          result = {};
  504.          result["name"] = className;
  505.          result["alias"] = classAlias;
  506.          result["properties"] = propertyNames;
  507.          result["dynamic"] = dynamic;
  508.          result["metadata"] = metadataInfo = recordMetadata(properties);
  509.          excludeObject = {};
  510.          if(excludes)
  511.          {
  512.             n = int(excludes.length);
  513.             i = 0;
  514.             while(i < n)
  515.             {
  516.                excludeObject[excludes[i]] = 1;
  517.                i++;
  518.             }
  519.          }
  520.          isArray = className == "Array";
  521.          if(dynamic)
  522.          {
  523.             for(p in obj)
  524.             {
  525.                if(excludeObject[p] != 1)
  526.                {
  527.                   if(isArray)
  528.                   {
  529.                      pi = parseInt(p);
  530.                      if(isNaN(pi))
  531.                      {
  532.                         propertyNames.push(new QName("",p));
  533.                      }
  534.                      else
  535.                      {
  536.                         propertyNames.push(pi);
  537.                      }
  538.                   }
  539.                   else
  540.                   {
  541.                      propertyNames.push(new QName("",p));
  542.                   }
  543.                }
  544.             }
  545.             numericIndex = isArray && !isNaN(Number(p));
  546.          }
  547.          if(!(className == "Object" || isArray))
  548.          {
  549.             if(className == "XML")
  550.             {
  551.                n = int(properties.length());
  552.                i = 0;
  553.                while(i < n)
  554.                {
  555.                   p = properties[i].name();
  556.                   if(excludeObject[p] != 1)
  557.                   {
  558.                      propertyNames.push(new QName("","@" + p));
  559.                   }
  560.                   i++;
  561.                }
  562.             }
  563.             else
  564.             {
  565.                n = int(properties.length());
  566.                uris = options.uris;
  567.                i = 0;
  568.                for(; i < n; i++)
  569.                {
  570.                   prop = properties[i];
  571.                   p = prop.@name.toString();
  572.                   uri = prop.@uri.toString();
  573.                   if(excludeObject[p] != 1)
  574.                   {
  575.                      if(!(!options.includeTransient && internalHasMetadata(metadataInfo,p,"Transient")))
  576.                      {
  577.                         if(uris != null)
  578.                         {
  579.                            if(uris.length == 1 && uris[0] == "*")
  580.                            {
  581.                               qName = new QName(uri,p);
  582.                               try
  583.                               {
  584.                                  obj[qName];
  585.                                  propertyNames.push();
  586.                               }
  587.                               catch(e:Error)
  588.                               {
  589.                               }
  590.                            }
  591.                            else
  592.                            {
  593.                               j = 0;
  594.                               while(j < uris.length)
  595.                               {
  596.                                  uri = uris[j];
  597.                                  if(prop.@uri.toString() == uri)
  598.                                  {
  599.                                     qName = new QName(uri,p);
  600.                                     try
  601.                                     {
  602.                                        obj[qName];
  603.                                        propertyNames.push(qName);
  604.                                     }
  605.                                     catch(e:Error)
  606.                                     {
  607.                                     }
  608.                                  }
  609.                                  j++;
  610.                               }
  611.                            }
  612.                         }
  613.                         else if(uri.length == 0)
  614.                         {
  615.                            qName = new QName(uri,p);
  616.                            try
  617.                            {
  618.                               obj[qName];
  619.                               propertyNames.push(qName);
  620.                            }
  621.                            catch(e:Error)
  622.                            {
  623.                            }
  624.                            continue;
  625.                         }
  626.                      }
  627.                   }
  628.                }
  629.             }
  630.          }
  631.          propertyNames.sort(Array.CASEINSENSITIVE | (numericIndex ? Array.NUMERIC : 0));
  632.          i = 0;
  633.          while(i < propertyNames.length - 1)
  634.          {
  635.             if(propertyNames[i].toString() == propertyNames[i + 1].toString())
  636.             {
  637.                propertyNames.splice(i,1);
  638.                i--;
  639.             }
  640.             i++;
  641.          }
  642.          if(!dynamic)
  643.          {
  644.             cacheKey = getCacheKey(obj,excludes,options);
  645.             CLASS_INFO_CACHE[cacheKey] = result;
  646.          }
  647.          return result;
  648.       }
  649.       
  650.       private static function internalHasMetadata(param1:Object, param2:String, param3:String) : Boolean
  651.       {
  652.          var _loc4_:Object = null;
  653.          if(param1 != null)
  654.          {
  655.             _loc4_ = param1[param2];
  656.             if(_loc4_ != null)
  657.             {
  658.                if(_loc4_[param3] != null)
  659.                {
  660.                   return true;
  661.                }
  662.             }
  663.          }
  664.          return false;
  665.       }
  666.       
  667.       private static function newline(param1:String, param2:int = 0) : String
  668.       {
  669.          var _loc3_:* = null;
  670.          var _loc4_:int = 0;
  671.          _loc3_ = param1;
  672.          _loc3_ += "\n";
  673.          _loc4_ = 0;
  674.          while(_loc4_ < param2)
  675.          {
  676.             _loc3_ += " ";
  677.             _loc4_++;
  678.          }
  679.          return _loc3_;
  680.       }
  681.       
  682.       public static function copy(param1:Object) : Object
  683.       {
  684.          var _loc2_:ByteArray = null;
  685.          var _loc3_:Object = null;
  686.          _loc2_ = new ByteArray();
  687.          _loc2_.writeObject(param1);
  688.          _loc2_.position = 0;
  689.          return _loc2_.readObject();
  690.       }
  691.       
  692.       public static function dateCompare(param1:Date, param2:Date) : int
  693.       {
  694.          var _loc3_:Number = NaN;
  695.          var _loc4_:Number = NaN;
  696.          if(param1 == null && param2 == null)
  697.          {
  698.             return 0;
  699.          }
  700.          if(param1 == null)
  701.          {
  702.             return 1;
  703.          }
  704.          if(param2 == null)
  705.          {
  706.             return -1;
  707.          }
  708.          _loc3_ = Number(param1.getTime());
  709.          _loc4_ = Number(param2.getTime());
  710.          if(_loc3_ < _loc4_)
  711.          {
  712.             return -1;
  713.          }
  714.          if(_loc3_ > _loc4_)
  715.          {
  716.             return 1;
  717.          }
  718.          return 0;
  719.       }
  720.       
  721.       private static function getCacheKey(param1:Object, param2:Array = null, param3:Object = null) : String
  722.       {
  723.          var _loc4_:String = null;
  724.          var _loc5_:uint = 0;
  725.          var _loc6_:String = null;
  726.          var _loc7_:String = null;
  727.          var _loc8_:String = null;
  728.          _loc4_ = getQualifiedClassName(param1);
  729.          if(param2 != null)
  730.          {
  731.             _loc5_ = 0;
  732.             while(_loc5_ < param2.length)
  733.             {
  734.                _loc6_ = param2[_loc5_] as String;
  735.                if(_loc6_ != null)
  736.                {
  737.                   _loc4_ += _loc6_;
  738.                }
  739.                _loc5_++;
  740.             }
  741.          }
  742.          if(param3 != null)
  743.          {
  744.             for(_loc7_ in param3)
  745.             {
  746.                _loc4_ += _loc7_;
  747.                _loc8_ = param3[_loc7_] as String;
  748.                if(_loc8_ != null)
  749.                {
  750.                   _loc4_ += _loc8_;
  751.                }
  752.             }
  753.          }
  754.          return _loc4_;
  755.       }
  756.       
  757.       public static function stringCompare(param1:String, param2:String, param3:Boolean = false) : int
  758.       {
  759.          var _loc4_:int = 0;
  760.          if(param1 == null && param2 == null)
  761.          {
  762.             return 0;
  763.          }
  764.          if(param1 == null)
  765.          {
  766.             return 1;
  767.          }
  768.          if(param2 == null)
  769.          {
  770.             return -1;
  771.          }
  772.          if(param3)
  773.          {
  774.             param1 = param1.toLocaleLowerCase();
  775.             param2 = param2.toLocaleLowerCase();
  776.          }
  777.          _loc4_ = int(param1.localeCompare(param2));
  778.          if(_loc4_ < -1)
  779.          {
  780.             _loc4_ = -1;
  781.          }
  782.          else if(_loc4_ > 1)
  783.          {
  784.             _loc4_ = 1;
  785.          }
  786.          return _loc4_;
  787.       }
  788.       
  789.       public static function isSimple(param1:Object) : Boolean
  790.       {
  791.          var _loc2_:* = null;
  792.          _loc2_ = typeof param1;
  793.          switch(_loc2_)
  794.          {
  795.             case "number":
  796.             case "string":
  797.             case "boolean":
  798.                return true;
  799.             case "object":
  800.                return param1 is Date || param1 is Array;
  801.             default:
  802.                return false;
  803.          }
  804.       }
  805.       
  806.       public static function numericCompare(param1:Number, param2:Number) : int
  807.       {
  808.          if(isNaN(param1) && isNaN(param2))
  809.          {
  810.             return 0;
  811.          }
  812.          if(isNaN(param1))
  813.          {
  814.             return 1;
  815.          }
  816.          if(isNaN(param2))
  817.          {
  818.             return -1;
  819.          }
  820.          if(param1 < param2)
  821.          {
  822.             return -1;
  823.          }
  824.          if(param1 > param2)
  825.          {
  826.             return 1;
  827.          }
  828.          return 0;
  829.       }
  830.    }
  831. }
  832.  
  833.